పైథాన్ జాంగో టెస్టింగ్: TestCase vs. TransactionTestCase

సాఫ్ట్‌వేర్ డెవలప్‌మెంట్‌లో టెస్టింగ్ ఒక కీలకమైన అంశం, ఇది మీ అప్లికేషన్ అనుకున్న విధంగా పనిచేస్తుందని మరియు కాలక్రమేణా దృఢంగా ఉంటుందని నిర్ధారిస్తుంది. ప్రముఖ పైథాన్ వెబ్ ఫ్రేమ్‌వర్క్ అయిన జాంగో, సమర్థవంతమైన పరీక్షలు రాయడంలో మీకు సహాయపడటానికి ఒక శక్తివంతమైన టెస్టింగ్ ఫ్రేమ్‌వర్క్‌ను అందిస్తుంది. ఈ బ్లాగ్ పోస్ట్ జాంగో యొక్క టెస్టింగ్ ఫ్రేమ్‌వర్క్‌లోని రెండు ప్రాథమిక క్లాస్‌లపై లోతుగా పరిశీలిస్తుంది: TestCase మరియు TransactionTestCase. వాటి మధ్య తేడాలు, వినియోగ సందర్భాలు, మరియు మీ టెస్టింగ్ అవసరాలకు సరైన క్లాస్‌ను ఎంచుకోవడంలో మీకు సహాయపడటానికి ఆచరణాత్మక ఉదాహరణలను మేము అన్వేషిస్తాము.

జాంగోలో టెస్టింగ్ ఎందుకు ముఖ్యం

TestCase మరియు TransactionTestCase యొక్క వివరాలలోకి వెళ్ళే ముందు, జాంగో డెవలప్‌మెంట్‌లో టెస్టింగ్ ఎందుకు అంత ముఖ్యమైనదో క్లుప్తంగా చర్చిద్దాం:

• కోడ్ నాణ్యతను నిర్ధారిస్తుంది: డెవలప్‌మెంట్ ప్రక్రియలో ప్రారంభంలోనే బగ్‌లను గుర్తించడంలో పరీక్షలు మీకు సహాయపడతాయి, అవి ప్రొడక్షన్‌లోకి ప్రవేశించకుండా నిరోధిస్తాయి.
• రీఫ్యాక్టరింగ్‌ను సులభతరం చేస్తుంది: సమగ్రమైన టెస్ట్ సూట్‌తో, మీరు విశ్వాసంతో మీ కోడ్‌ను రీఫ్యాక్టర్ చేయవచ్చు, మీరు ఏదైనా రిగ్రెషన్‌లను ప్రవేశపెడితే పరీక్షలు మీకు తెలియజేస్తాయని తెలుసుకోండి.
• సహకారాన్ని మెరుగుపరుస్తుంది: చక్కగా వ్రాసిన పరీక్షలు మీ కోడ్‌కు డాక్యుమెంటేషన్‌గా పనిచేస్తాయి, ఇతర డెవలపర్‌లు అర్థం చేసుకోవడానికి మరియు సహకరించడానికి సులభతరం చేస్తాయి.
• టెస్ట్-డ్రివెన్ డెవలప్‌మెంట్ (TDD)కు మద్దతు ఇస్తుంది: TDD అనేది మీరు వాస్తవ కోడ్ రాయడానికి ముందు పరీక్షలను వ్రాసే డెవలప్‌మెంట్ విధానం. ఇది మీ అప్లికేషన్ యొక్క కావలసిన ప్రవర్తన గురించి ముందుగానే ఆలోచించేలా మిమ్మల్ని బలవంతం చేస్తుంది, ఇది శుభ్రమైన మరియు మరింత నిర్వహించదగిన కోడ్‌కు దారితీస్తుంది.

జాంగో యొక్క టెస్టింగ్ ఫ్రేమ్‌వర్క్: ఒక త్వరిత అవలోకనం

జాంగో యొక్క టెస్టింగ్ ఫ్రేమ్‌వర్క్ పైథాన్ యొక్క అంతర్నిర్మిత unittest మాడ్యూల్‌పై నిర్మించబడింది. ఇది జాంగో అప్లికేషన్‌లను పరీక్షించడాన్ని సులభతరం చేసే అనేక లక్షణాలను అందిస్తుంది, వీటిలో:

• టెస్ట్ డిస్కవరీ: జాంగో మీ ప్రాజెక్ట్‌లోని పరీక్షలను స్వయంచాలకంగా కనుగొని అమలు చేస్తుంది.
• టెస్ట్ రన్నర్: జాంగో మీ పరీక్షలను అమలు చేసే మరియు ఫలితాలను నివేదించే టెస్ట్ రన్నర్‌ను అందిస్తుంది.
• అసెర్షన్ మెథడ్స్: మీ కోడ్ యొక్క కావలసిన ప్రవర్తనను ధృవీకరించడానికి మీరు ఉపయోగించగల అసెర్షన్ మెథడ్స్ యొక్క సెట్‌ను జాంగో అందిస్తుంది.
• క్లయింట్: జాంగో యొక్క టెస్ట్ క్లయింట్ ఫారమ్‌లను సమర్పించడం లేదా API అభ్యర్థనలు చేయడం వంటి మీ అప్లికేషన్‌తో వినియోగదారు పరస్పర చర్యలను అనుకరించడానికి మిమ్మల్ని అనుమతిస్తుంది.
• TestCase మరియు TransactionTestCase: ఇవి జాంగోలో పరీక్షలు రాయడానికి రెండు ప్రాథమిక క్లాస్‌లు, వీటిని మేము వివరంగా అన్వేషిస్తాము.

TestCase: వేగవంతమైన మరియు సమర్థవంతమైన యూనిట్ టెస్టింగ్

TestCase అనేది జాంగోలో యూనిట్ పరీక్షలు రాయడానికి ప్రాథమిక క్లాస్. ఇది ప్రతి టెస్ట్ కేస్ కోసం ఒక శుభ్రమైన డేటాబేస్ వాతావరణాన్ని అందిస్తుంది, పరీక్షలు వివిక్తంగా ఉంటాయని మరియు ఒకదానికొకటి జోక్యం చేసుకోకుండా నిర్ధారిస్తుంది.

TestCase ఎలా పనిచేస్తుంది

మీరు TestCase ఉపయోగించినప్పుడు, జాంగో ప్రతి టెస్ట్ మెథడ్ కోసం ఈ క్రింది దశలను నిర్వహిస్తుంది:

1. టెస్ట్ డేటాబేస్‌ను సృష్టిస్తుంది: జాంగో ప్రతి టెస్ట్ రన్ కోసం ఒక ప్రత్యేక టెస్ట్ డేటాబేస్‌ను సృష్టిస్తుంది.
2. డేటాబేస్‌ను ఫ్లష్ చేస్తుంది: ప్రతి టెస్ట్ మెథడ్‌కు ముందు, జాంగో టెస్ట్ డేటాబేస్‌ను ఫ్లష్ చేస్తుంది, అన్ని ప్రస్తుత డేటాను తొలగిస్తుంది.
3. టెస్ట్ మెథడ్‌ను రన్ చేస్తుంది: జాంగో మీరు నిర్వచించిన టెస్ట్ మెథడ్‌ను అమలు చేస్తుంది.
4. ట్రాన్సాక్షన్‌ను రోల్‌బ్యాక్ చేస్తుంది: ప్రతి టెస్ట్ మెథడ్ తర్వాత, జాంగో ట్రాన్సాక్షన్‌ను రోల్‌బ్యాక్ చేస్తుంది, పరీక్ష సమయంలో డేటాబేస్‌కు చేసిన ఏవైనా మార్పులను సమర్థవంతంగా రద్దు చేస్తుంది.

ఈ విధానం ప్రతి టెస్ట్ మెథడ్ ఒక శుభ్రమైన స్లేట్‌తో ప్రారంభమవుతుందని మరియు డేటాబేస్‌కు చేసిన ఏవైనా మార్పులు స్వయంచాలకంగా రద్దు చేయబడతాయని నిర్ధారిస్తుంది. ఇది TestCase ను యూనిట్ టెస్టింగ్‌కు ఆదర్శంగా చేస్తుంది, ఇక్కడ మీరు మీ అప్లికేషన్ యొక్క వ్యక్తిగత భాగాలను వివిక్తంగా పరీక్షించాలనుకుంటారు.

ఉదాహరణ: ఒక సాధారణ మోడల్‌ను పరీక్షించడం

TestCase ఉపయోగించి ఒక జాంగో మోడల్‌ను పరీక్షించడానికి ఒక సాధారణ ఉదాహరణను పరిశీలిద్దాం:

from django.test import TestCase
from .models import Product

class ProductModelTest(TestCase):
 def test_product_creation(self):
 product = Product.objects.create(name="Test Product", price=10.00)
 self.assertEqual(product.name, "Test Product")
 self.assertEqual(product.price, 10.00)
 self.assertTrue(isinstance(product, Product))

ఈ ఉదాహరణలో, మేము Product మోడల్ ఇన్‌స్టాన్స్‌ను సృష్టించడాన్ని పరీక్షిస్తున్నాము. test_product_creation మెథడ్ ఒక కొత్త ఉత్పత్తిని సృష్టిస్తుంది మరియు ఉత్పత్తి యొక్క లక్షణాలు సరిగ్గా సెట్ చేయబడ్డాయని ధృవీకరించడానికి అసెర్షన్ మెథడ్స్‌ను ఉపయోగిస్తుంది.

TestCaseను ఎప్పుడు ఉపయోగించాలి

TestCase అనేది చాలా జాంగో టెస్టింగ్ దృశ్యాలకు సాధారణంగా ప్రాధాన్యత ఇవ్వబడుతుంది. ఇది వేగంగా, సమర్థవంతంగా ఉంటుంది మరియు ప్రతి పరీక్ష కోసం ఒక శుభ్రమైన డేటాబేస్ వాతావరణాన్ని అందిస్తుంది. TestCaseను ఉపయోగించండి:

• మీ అప్లికేషన్ యొక్క వ్యక్తిగత మోడల్స్, వ్యూస్ లేదా ఇతర భాగాలను మీరు పరీక్షిస్తున్నప్పుడు.
• మీ పరీక్షలు వివిక్తంగా ఉన్నాయని మరియు ఒకదానికొకటి జోక్యం చేసుకోకుండా మీరు నిర్ధారించుకోవాలనుకున్నప్పుడు.
• బహుళ ట్రాన్సాక్షన్‌లను విస్తరించే సంక్లిష్ట డేటాబేస్ పరస్పర చర్యలను మీరు పరీక్షించాల్సిన అవసరం లేనప్పుడు.

TransactionTestCase: సంక్లిష్ట డేటాబేస్ పరస్పర చర్యలను పరీక్షించడం

TransactionTestCase అనేది జాంగోలో పరీక్షలు రాయడానికి మరో క్లాస్, కానీ డేటాబేస్ ట్రాన్సాక్షన్‌లను ఇది నిర్వహించే విధానంలో TestCase నుండి భిన్నంగా ఉంటుంది. ప్రతి టెస్ట్ మెథడ్ తర్వాత ట్రాన్సాక్షన్‌ను రోల్‌బ్యాక్ చేయడానికి బదులుగా, TransactionTestCase ట్రాన్సాక్షన్‌ను కమిట్ చేస్తుంది. ఇది బహుళ ట్రాన్సాక్షన్‌లను విస్తరించే సంక్లిష్ట డేటాబేస్ పరస్పర చర్యలను పరీక్షించడానికి అనుకూలంగా ఉంటుంది, సిగ్నల్స్ లేదా అటామిక్ ట్రాన్సాక్షన్‌లను కలిగి ఉన్నవి.

TransactionTestCase ఎలా పనిచేస్తుంది

మీరు TransactionTestCase ఉపయోగించినప్పుడు, జాంగో ప్రతి టెస్ట్ కేస్ కోసం ఈ క్రింది దశలను నిర్వహిస్తుంది:

1. టెస్ట్ డేటాబేస్‌ను సృష్టిస్తుంది: జాంగో ప్రతి టెస్ట్ రన్ కోసం ఒక ప్రత్యేక టెస్ట్ డేటాబేస్‌ను సృష్టిస్తుంది.
2. డేటాబేస్‌ను ఫ్లష్ చేయదు: TransactionTestCase ప్రతి పరీక్షకు ముందు డేటాబేస్‌ను స్వయంచాలకంగా ఫ్లష్ చేయదు. ఇది ప్రతి పరీక్ష అమలు చేయడానికి ముందు డేటాబేస్ స్థిరమైన స్థితిలో ఉండాలని ఆశిస్తుంది.
3. టెస్ట్ మెథడ్‌ను రన్ చేస్తుంది: జాంగో మీరు నిర్వచించిన టెస్ట్ మెథడ్‌ను అమలు చేస్తుంది.
4. ట్రాన్సాక్షన్‌ను కమిట్ చేస్తుంది: ప్రతి టెస్ట్ మెథడ్ తర్వాత, జాంగో ట్రాన్సాక్షన్‌ను కమిట్ చేస్తుంది, మార్పులను టెస్ట్ డేటాబేస్‌లో శాశ్వతంగా చేస్తుంది.
5. టేబుల్స్‌ను ట్రిమ్ చేస్తుంది: TransactionTestCaseలోని అన్ని పరీక్షల *ముగింపులో*, డేటాను క్లియర్ చేయడానికి టేబుల్స్ ట్రిమ్ చేయబడతాయి.

TransactionTestCase ప్రతి టెస్ట్ మెథడ్ తర్వాత ట్రాన్సాక్షన్‌ను కమిట్ చేస్తుంది కాబట్టి, మీ పరీక్షలు డేటాబేస్‌ను అస్థిర స్థితిలో వదిలివేయలేదని నిర్ధారించుకోవడం చాలా ముఖ్యం. తదుపరి పరీక్షలకు ఆటంకం కలిగించకుండా నివారించడానికి పరీక్ష సమయంలో సృష్టించబడిన ఏ డేటాను అయినా మీరు మాన్యువల్‌గా శుభ్రం చేయవలసి ఉంటుంది.

ఉదాహరణ: సిగ్నల్స్‌ను పరీక్షించడం

TransactionTestCase ఉపయోగించి జాంగో సిగ్నల్స్‌ను పరీక్షించడానికి ఒక ఉదాహరణను పరిశీలిద్దాం:

from django.test import TransactionTestCase
from django.db.models.signals import post_save
from django.dispatch import receiver
from .models import Product, ProductLog

@receiver(post_save, sender=Product)
def create_product_log(sender, instance, created, **kwargs):
 if created:
 ProductLog.objects.create(product=instance, action="Created")

class ProductSignalTest(TransactionTestCase):
def test_product_creation_signal(self):
 product = Product.objects.create(name="Test Product", price=10.00)
 self.assertEqual(ProductLog.objects.count(), 1)
 self.assertEqual(ProductLog.objects.first().product, product)
 self.assertEqual(ProductLog.objects.first().action, "Created")

ఈ ఉదాహరణలో, మేము కొత్త Product ఇన్‌స్టాన్స్ సృష్టించబడినప్పుడు ProductLog ఇన్‌స్టాన్స్‌ను సృష్టించే సిగ్నల్‌ను పరీక్షిస్తున్నాము. test_product_creation_signal మెథడ్ ఒక కొత్త ఉత్పత్తిని సృష్టిస్తుంది మరియు ఆ తర్వాత సంబంధిత ఉత్పత్తి లాగ్ ఎంట్రీ సృష్టించబడిందని ధృవీకరిస్తుంది.

TransactionTestCaseను ఎప్పుడు ఉపయోగించాలి

TransactionTestCase సాధారణంగా సంక్లిష్ట డేటాబేస్ పరస్పర చర్యలను పరీక్షించాల్సిన నిర్దిష్ట సందర్భాలలో ఉపయోగించబడుతుంది, అవి బహుళ ట్రాన్సాక్షన్‌లను విస్తరిస్తాయి. TransactionTestCaseను ఉపయోగించడాన్ని పరిగణించండి:

• డేటాబేస్ కార్యకలాపాల ద్వారా ట్రిగ్గర్ చేయబడిన సిగ్నల్స్‌ను మీరు పరీక్షిస్తున్నప్పుడు.
• బహుళ డేటాబేస్ కార్యకలాపాలను కలిగి ఉన్న అటామిక్ ట్రాన్సాక్షన్‌లను మీరు పరీక్షిస్తున్నప్పుడు.
• సంబంధిత కార్యకలాపాల శ్రేణి తర్వాత డేటాబేస్ స్థితిని మీరు ధృవీకరించాల్సిన అవసరం ఉన్నప్పుడు.
• టెస్ట్‌ల మధ్య నిలిచి ఉండే ఆటో-ఇంక్రిమెంటింగ్ IDపై ఆధారపడే కోడ్‌ను మీరు ఉపయోగిస్తున్నప్పుడు (ఇది సాధారణంగా చెడ్డ పద్ధతిగా పరిగణించబడుతుంది).

TransactionTestCaseను ఉపయోగిస్తున్నప్పుడు ముఖ్యమైన పరిగణనలు

TransactionTestCase ట్రాన్సాక్షన్‌లను కమిట్ చేస్తుంది కాబట్టి, ఈ క్రింది పరిగణనలను తెలుసుకోవడం ముఖ్యం:

• డేటాబేస్ శుభ్రపరచడం: తదుపరి పరీక్షలకు ఆటంకం కలిగించకుండా నివారించడానికి పరీక్ష సమయంలో సృష్టించబడిన ఏ డేటాను అయినా మీరు మాన్యువల్‌గా శుభ్రం చేయవలసి ఉంటుంది. టెస్ట్ డేటాను నిర్వహించడానికి setUp మరియు tearDown మెథడ్స్‌ను ఉపయోగించడాన్ని పరిగణించండి.
• టెస్ట్ ఐసోలేషన్: TransactionTestCase TestCase వలె అదే స్థాయి టెస్ట్ ఐసోలేషన్‌ను అందించదు. పరీక్షల మధ్య సంభావ్య పరస్పర చర్యల గురించి తెలుసుకోండి మరియు మీ పరీక్షలు మునుపటి పరీక్షల నుండి డేటాబేస్ స్థితిపై ఆధారపడకుండా చూసుకోండి.
• పనితీరు: TransactionTestCase TestCase కంటే నెమ్మదిగా ఉంటుంది ఎందుకంటే ఇది ట్రాన్సాక్షన్‌లను కమిట్ చేయడం ఉంటుంది. దీనిని వివేకంతో మరియు అవసరమైనప్పుడు మాత్రమే ఉపయోగించండి.

జాంగో టెస్టింగ్‌కు ఉత్తమ పద్ధతులు

జాంగోలో పరీక్షలు రాస్తున్నప్పుడు గుర్తుంచుకోవలసిన కొన్ని ఉత్తమ పద్ధతులు ఇక్కడ ఉన్నాయి:

• స్పష్టమైన మరియు సంక్షిప్త పరీక్షలను రాయండి: పరీక్షలు అర్థం చేసుకోవడానికి మరియు నిర్వహించడానికి సులభంగా ఉండాలి. టెస్ట్ మెథడ్స్ మరియు అసెర్షన్స్‌కు వర్ణనాత్మక పేర్లను ఉపయోగించండి.
• ఒకేసారి ఒక విషయాన్ని పరీక్షించండి: ప్రతి టెస్ట్ మెథడ్ మీ కోడ్ యొక్క ఒకే అంశాన్ని పరీక్షించడంపై దృష్టి పెట్టాలి. ఇది టెస్ట్ విఫలమైనప్పుడు వైఫల్యం యొక్క మూలాన్ని గుర్తించడం సులభం చేస్తుంది.
• అర్థవంతమైన అసెర్షన్స్‌ను ఉపయోగించండి: మీ కోడ్ యొక్క కావలసిన ప్రవర్తనను స్పష్టంగా వ్యక్తీకరించే అసెర్షన్ మెథడ్స్‌ను ఉపయోగించండి. జాంగో వివిధ దృశ్యాల కోసం అసెర్షన్ మెథడ్స్ యొక్క గొప్ప సెట్‌ను అందిస్తుంది.
• Arrange-Act-Assert నమూనాను అనుసరించండి: Arrange-Act-Assert నమూనా ప్రకారం మీ పరీక్షలను నిర్వహించండి: టెస్ట్ డేటాను అమర్చండి, పరీక్షించబడుతున్న కోడ్‌పై చర్య తీసుకోండి, మరియు కావలసిన ఫలితాన్ని ధృవీకరించండి.
• మీ పరీక్షలను వేగంగా ఉంచండి: నెమ్మదిగా ఉండే పరీక్షలు డెవలపర్‌లు వాటిని తరచుగా అమలు చేయకుండా నిరుత్సాహపరచగలవు. ఎగ్జిక్యూషన్ సమయాన్ని తగ్గించడానికి మీ పరీక్షలను ఆప్టిమైజ్ చేయండి.
• టెస్ట్ డేటా కోసం ఫిక్చర్‌లను ఉపయోగించండి: మీ టెస్ట్ డేటాబేస్‌లోకి ప్రారంభ డేటాను లోడ్ చేయడానికి ఫిక్చర్‌లు ఒక అనుకూలమైన మార్గం. స్థిరమైన మరియు పునర్వినియోగపరచదగిన టెస్ట్ డేటాను సృష్టించడానికి ఫిక్చర్‌లను ఉపయోగించండి. IDలను హార్డ్‌కోడ్ చేయకుండా నివారించడానికి ఫిక్చర్‌లలో సహజ కీలను ఉపయోగించడాన్ని పరిగణించండి.
• pytest వంటి టెస్టింగ్ లైబ్రరీని ఉపయోగించడాన్ని పరిగణించండి: జాంగో యొక్క అంతర్నిర్మిత టెస్టింగ్ ఫ్రేమ్‌వర్క్ శక్తివంతమైనది అయినప్పటికీ, pytest వంటి లైబ్రరీలు అదనపు లక్షణాలు మరియు సౌలభ్యాన్ని అందించగలవు.
• అధిక టెస్ట్ కవరేజీ కోసం ప్రయత్నించండి: మీ కోడ్ సమగ్రంగా పరీక్షించబడిందని నిర్ధారించుకోవడానికి అధిక టెస్ట్ కవరేజీని లక్ష్యంగా చేసుకోండి. మీ టెస్ట్ కవరేజీని కొలవడానికి కవరేజ్ సాధనాలను ఉపయోగించండి మరియు మరిన్ని పరీక్షలు అవసరమయ్యే ప్రాంతాలను గుర్తించండి.
• మీ CI/CD పైప్‌లైన్‌లోకి పరీక్షలను ఇంటిగ్రేట్ చేయండి: మీ నిరంతర ఇంటిగ్రేషన్ మరియు నిరంతర విస్తరణ (CI/CD) పైప్‌లైన్‌లో భాగంగా మీ పరీక్షలను స్వయంచాలకంగా అమలు చేయండి. ఇది డెవలప్‌మెంట్ ప్రక్రియలో ప్రారంభంలోనే ఏవైనా రిగ్రెషన్‌లు కనుగొనబడతాయని నిర్ధారిస్తుంది.
• వాస్తవ-ప్రపంచ దృశ్యాలను ప్రతిబింబించే పరీక్షలను రాయండి: వినియోగదారులు వాస్తవంగా ఎలా సంభాషిస్తారో అనుకరించే మార్గాలలో మీ అప్లికేషన్‌ను పరీక్షించండి. ఇది సాధారణ యూనిట్ పరీక్షలలో కనిపించని బగ్‌లను బహిర్గతం చేయడంలో మీకు సహాయపడుతుంది. ఉదాహరణకు, ఫారమ్‌లను పరీక్షిస్తున్నప్పుడు అంతర్జాతీయ చిరునామాలు మరియు ఫోన్ నంబర్‌ల వైవిధ్యాలను పరిగణించండి.

అంతర్జాతీయీకరణ (i18n) మరియు టెస్టింగ్

ప్రపంచవ్యాప్త ప్రేక్షకులకు జాంగో అప్లికేషన్‌లను డెవలప్ చేస్తున్నప్పుడు, అంతర్జాతీయీకరణ (i18n) మరియు స్థానికీకరణ (l10n)ను పరిగణనలోకి తీసుకోవడం చాలా ముఖ్యం. వివిధ భాషలు, తేదీ ఆకృతులు మరియు కరెన్సీ చిహ్నాల కోసం మీ పరీక్షలు కవర్ అవుతాయని నిర్ధారించుకోండి. ఇక్కడ కొన్ని చిట్కాలు ఉన్నాయి:

• వివిధ భాషా సెట్టింగ్‌లతో పరీక్షించండి: వివిధ భాషా సెట్టింగ్‌లతో మీ అప్లికేషన్‌ను పరీక్షించడానికి జాంగో యొక్క override_settings డెకరేటర్‌ను ఉపయోగించండి.
• మీ పరీక్షలలో స్థానికీకరించిన డేటాను ఉపయోగించండి: మీ అప్లికేషన్ విభిన్న తేదీ ఆకృతులు, కరెన్సీ చిహ్నాలు మరియు ఇతర స్థానిక-నిర్దిష్ట డేటాను సరిగ్గా నిర్వహిస్తుందని నిర్ధారించడానికి మీ టెస్ట్ ఫిక్చర్‌లు మరియు టెస్ట్ మెథడ్స్‌లో స్థానికీకరించిన డేటాను ఉపయోగించండి.
• మీ అనువాద స్ట్రింగ్‌లను పరీక్షించండి: మీ అనువాద స్ట్రింగ్‌లు సరిగ్గా అనువదించబడిందని మరియు అవి వివిధ భాషలలో సరిగ్గా రెండర్ అవుతాయని ధృవీకరించండి.
• localize టెంప్లేట్ ట్యాగ్‌ను ఉపయోగించండి: మీ టెంప్లేట్‌లలో, వినియోగదారు యొక్క ప్రస్తుత లోకేల్ ప్రకారం తేదీలు, సంఖ్యలు మరియు ఇతర లోకేల్-నిర్దిష్ట డేటాను ఫార్మాట్ చేయడానికి localize టెంప్లేట్ ట్యాగ్‌ను ఉపయోగించండి.

ఉదాహరణ: విభిన్న భాషా సెట్టింగ్‌లతో పరీక్షించడం

from django.test import TestCase
from django.utils import translation
from django.conf import settings

class InternationalizationTest(TestCase):

 def test_localized_date_format(self):
 original_language = translation.get_language()
 try:
 translation.activate('de') # Activate German language
 with self.settings(LANGUAGE_CODE='de'): # Set the language in settings
 from django.utils import formats
 from datetime import date
 d = date(2024, 1, 20)
 formatted_date = formats.date_format(d, 'SHORT_DATE_FORMAT')
 self.assertEqual(formatted_date, '20.01.2024')
 finally:
 translation.activate(original_language) # Restore original language

ఈ ఉదాహరణ జాంగో యొక్క translation మరియు formats మాడ్యూల్స్‌ను ఉపయోగించి విభిన్న భాషా సెట్టింగ్‌లతో తేదీ ఫార్మాటింగ్‌ను ఎలా పరీక్షించాలో వివరిస్తుంది.

ముగింపు

జాంగోలో సమర్థవంతమైన మరియు నమ్మకమైన పరీక్షలు రాయడానికి TestCase మరియు TransactionTestCase మధ్య తేడాలను అర్థం చేసుకోవడం చాలా అవసరం. TestCase అనేది చాలా టెస్టింగ్ దృశ్యాలకు సాధారణంగా ప్రాధాన్యత ఇవ్వబడుతుంది, మీ అప్లికేషన్ యొక్క వ్యక్తిగత భాగాలను వివిక్తంగా పరీక్షించడానికి వేగవంతమైన మరియు సమర్థవంతమైన మార్గాన్ని అందిస్తుంది. TransactionTestCase అనేది సిగ్నల్స్ లేదా అటామిక్ ట్రాన్సాక్షన్‌లను కలిగి ఉన్న బహుళ ట్రాన్సాక్షన్‌లను విస్తరించే సంక్లిష్ట డేటాబేస్ పరస్పర చర్యలను పరీక్షించడానికి ఉపయోగపడుతుంది. ఉత్తమ పద్ధతులను అనుసరించడం మరియు అంతర్జాతీయీకరణ అంశాలను పరిగణనలోకి తీసుకోవడం ద్వారా, మీరు మీ జాంగో అప్లికేషన్‌ల నాణ్యత మరియు నిర్వహణను నిర్ధారించే ఒక దృఢమైన టెస్ట్ సూట్‌ను సృష్టించవచ్చు.

మరింత అభ్యాసం

• జాంగో టెస్టింగ్ డాక్యుమెంటేషన్
• పైథాన్ unittest డాక్యుమెంటేషన్
• pytest డాక్యుమెంటేషన్